//
//  ViewController1.swift
//  RXSwiftTest
//
//  Created by ZhangBo on 2019/4/13.
//  Copyright © 2019 ZhangBo. All rights reserved.
//

import UIKit
import RxSwift
import RxCocoa


class RxViewController1: BaseViewController {
    let disposeB = DisposeBag()

    override func viewDidLoad() {
        super.viewDidLoad()
//        testRxSwiftCreat()
        testUI()
    }
}

extension RxViewController1 {

    func testRxSwiftCreat() {

        //1.产生序列
        let ob = Observable<Any>.create { (anyObser) -> Disposable in
            print("**************")
            print(anyObser)
            //3.发送序列
            anyObser.onNext("我与世界只差一个你")
            anyObser.onError(NameSpace1.MyError.errorB)
            anyObser.onCompleted()
            return Disposables.create()
        }

        //2.订阅序列
        ob.subscribe(onNext: { (signal) in
            print(signal)
        }, onError: { (error) in
            print(error)
        }, onCompleted: {
            print("完成了")
        }) {
            print("销毁了")
        }.disposed(by: disposeB)
    }
}

extension RxViewController1 {

    func testUI() {

        var frame = CGRect(x: 50, y: 150, width: 100, height: 30)

        let textf = UITextField(frame:frame)
        textf.borderStyle = UITextBorderStyle.roundedRect
        self.view.addSubview(textf)

        frame.origin.y = 190

        let label = UILabel(frame: frame)
        label.textColor = UIColor.orange
        self.view.addSubview(label)


        frame.origin.y = 240

        let btn = UIButton(type: .system)
        btn.frame = frame
        btn.setTitle("登录", for: UIControlState.normal)
        self.view.addSubview(btn)

        //rac_textsignal //每个一段时间 才发送
        let inputTFOb = textf.rx.text.orEmpty.asDriver().throttle(0.5)

        //绑定到label
        inputTFOb.map {
            "当前输入的是:\($0)"
        }.drive(label.rx.text).disposed(by: disposeB)

        //绑定到Button.ieEnable
        inputTFOb.map {
            $0.count > 5
        }.drive(btn.rx.isEnabled).disposed(by: disposeB)

        //绑定到Button //btn.rx.拓展
        inputTFOb.asObservable().bind(to: btn.rx.title()).disposed(by: disposeB)
//        inputTFOb.asObservable().bind(to: label.rx.text).disposed(by: disposeB)

        //双向绑定操作符
        let text = Variable("希望")
        _ = textf.rx.textInput <-> text

        //按钮点击事件
        //[weak self]  [own self]
        btn.rx.tap.subscribe(onNext: { [weak self]() in
            self?.view.backgroundColor = UIColor.orange
            print("点击了")
            self?.navigationController?.pushViewController(TestViewController(), animated: true)
        }).disposed(by: disposeB)


    }
}


extension RxViewController1 {
    func testRxSwift02() {
        //通过指定的方法实现来自定义一个被观察的序列。
        //订阅创建
        let myOb = Observable<Any>.create { (observ) -> Disposable in
            observ.onNext("cooci")
            observ.onCompleted()
            return Disposables.create()
        }
        //订阅事件
        myOb.subscribe { (even) in
            print(even)
        }.disposed(by: disposeB)//销毁

        //各种观察者序列产生方式

        //该方法通过传入一个默认值来初始化。
        Observable.just("just").subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该方法可以接受可变数量的参数（必需要是同类型的）
        Observable.of("o", "f", "of").subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该方法需要一个数组参数。
        Observable.from(["f", "r", "o", "m"]).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该方法创建一个永远不会发出 Event（也不会终止）的 Observable 序列。
        Observable<Int>.never().subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该方法创建一个空内容的 Observable 序列。 //会打印complete
        Observable<Int>.empty().subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该方法创建一个不做任何操作，而是直接发送一个错误的 Observable 序列。
        let myError = NameSpace1.MyError.errorA
        //        print(myError.errorType)
        Observable<Int>.error(myError).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该方法通过指定起始和结束数值，创建一个以这个范围内所有值作为初始值的Observable序列。
        Observable.range(start: 1, count: 6).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该方法创建一个可以无限发出给定元素的 Event的 Observable 序列（永不终止）。
        //        Observable.repeatElement("Cooci").subscribe { (event) in
        //            print(event)
        //        }.disposed(by: disposeB)

        //该方法创建一个只有当提供的所有的判断条件都为 true 的时候，才会给出动作的 Observable 序列。
        //第一个参数:初始化的数值  第二个 条件  第三也是一个条件 0 + 2 <= 10 依次循环下去,iterate:重复执行
        Observable.generate(initialState: 0, condition: { $0 <= 10 }, iterate: { $0 + 2 }).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //上面和下面的效果一样
        Observable.of(0, 2, 4, 6, 8, 10).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

        //该个方法相当于是创建一个 Observable 工厂，通过传入一个 block 来执行延迟 Observable序列创建的行为，而这个 block 里就是真正的实例化序列对象的地方。
        var isOdd = true
        let factory: Observable<Int> = Observable.deferred { () -> Observable<Int> in

            isOdd = !isOdd
            if isOdd {
                return Observable.of(0, 2, 4, 6, 8)
            } else {
                return Observable.of(1, 3, 5, 7, 9)
            }
        }

        factory.subscribe { (event) in
            print("\(isOdd)", event)
        }.disposed(by: disposeB)

        factory.subscribe { (event) in
            print("\(isOdd)", event)
        }.disposed(by: disposeB)


        //这个方法创建的 Observable 序列每隔一段设定的时间，会发出一个索引数的元素。而且它会一直发送下去。

        //        Observable<Int>.interval(1, scheduler: MainScheduler.instance).subscribe { (event) in
        //            print(event)
        //        }.disposed(by: disposeB)

        //这个方法有两种用法，一种是创建的 Observable序列在经过设定的一段时间后，产生唯一的一个元素。
        //        Observable<Int>.timer(1, scheduler: MainScheduler.instance).subscribe{(event) in
        //            print("123",event)
        //        }.disposed(by: disposeB)
        //
        //
        //另一种是创建的 Observable 序列在经过设定的一段时间后，每隔一段时间产生一个元素。
        Observable<Int>.timer(5, period: 1, scheduler: MainScheduler.instance).subscribe { (event) in
            print(event)
        }.disposed(by: disposeB)

    }
}


